time/[root]

Package-level declarations

Types

DateTimeComponentOutOfBoundsException

class DateTimeComponentOutOfBoundsException : RuntimeException

IllegalTimeUnitException

class IllegalTimeUnitException : IllegalArgumentException

MissingDateTimeComponentsException

class MissingDateTimeComponentsException : IllegalArgumentException

Relation

enum Relation : Enum<Relation>

The relationship between two calendar values.

TimeDifference

data class TimeDifference<SmallestUnit : TimeUnit>

TimePeriod

data class TimePeriod<SmallestUnit : TimeUnit> : Comparable<TimePeriod<SmallestUnit>>

TimeUnit

sealed class TimeUnit

Properties

dayOfMonth

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.dayOfMonth: Int

dayOfWeek

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.dayOfWeek: DayOfWeek

dayOfYear

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.dayOfYear: Int

dayPeriod

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.dayPeriod: TimePeriod<TimeUnit.Day>

days

val TimeDifference<TimeUnit.Day>.days: Int

@get:JvmName(name = "monthDays")

val TimePeriod<TimeUnit.Month>.days: Sequence<TimePeriod<TimeUnit.Day>>

@get:JvmName(name = "yearDays")

val TimePeriod<TimeUnit.Year>.days: Sequence<TimePeriod<TimeUnit.Day>>

firstDay

@get:JvmName(name = "monthFirstDay")

val TimePeriod<TimeUnit.Month>.firstDay: TimePeriod<TimeUnit.Day>

@get:JvmName(name = "yearFirstDay")

val TimePeriod<TimeUnit.Year>.firstDay: TimePeriod<TimeUnit.Day>

firstHour

@get:JvmName(name = "dayFirstHour")

val TimePeriod<TimeUnit.Day>.firstHour: TimePeriod<TimeUnit.Hour>

@get:JvmName(name = "monthFirstHour")

val TimePeriod<TimeUnit.Month>.firstHour: TimePeriod<TimeUnit.Hour>

firstMinute

@get:JvmName(name = "dayFirstMinute")

val TimePeriod<TimeUnit.Day>.firstMinute: TimePeriod<TimeUnit.Minute>

@get:JvmName(name = "hourFirstMinute")

val TimePeriod<TimeUnit.Hour>.firstMinute: TimePeriod<TimeUnit.Minute>

firstMonth

val TimePeriod<TimeUnit.Year>.firstMonth: TimePeriod<TimeUnit.Month>

firstSecond

@get:JvmName(name = "dayFirstSecond")

val TimePeriod<TimeUnit.Day>.firstSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "hourFirstSecond")

val TimePeriod<TimeUnit.Hour>.firstSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "minuteFirstSecond")

val TimePeriod<TimeUnit.Minute>.firstSecond: TimePeriod<TimeUnit.Second>

hour

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.hour: Int

hourPeriod

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.hourPeriod: TimePeriod<TimeUnit.Hour>

hours

val TimeDifference<TimeUnit.Hour>.hours: Int

@get:JvmName(name = "dayHours")

val TimePeriod<TimeUnit.Day>.hours: Sequence<TimePeriod<TimeUnit.Hour>>

@get:JvmName(name = "monthHours")

val TimePeriod<TimeUnit.Month>.hours: Sequence<TimePeriod<TimeUnit.Hour>>

lastDay

@get:JvmName(name = "monthLastDay")

val TimePeriod<TimeUnit.Month>.lastDay: TimePeriod<TimeUnit.Day>

@get:JvmName(name = "yearLastDay")

val TimePeriod<TimeUnit.Year>.lastDay: TimePeriod<TimeUnit.Day>

lastHour

@get:JvmName(name = "dayLastHour")

val TimePeriod<TimeUnit.Day>.lastHour: TimePeriod<TimeUnit.Hour>

@get:JvmName(name = "monthLastHour")

val TimePeriod<TimeUnit.Month>.lastHour: TimePeriod<TimeUnit.Hour>

lastMinute

@get:JvmName(name = "dayLastMinute")

val TimePeriod<TimeUnit.Day>.lastMinute: TimePeriod<TimeUnit.Minute>

@get:JvmName(name = "hourLastMinute")

val TimePeriod<TimeUnit.Hour>.lastMinute: TimePeriod<TimeUnit.Minute>

lastMonth

val TimePeriod<TimeUnit.Year>.lastMonth: TimePeriod<TimeUnit.Month>

lastSecond

@get:JvmName(name = "dayLastSecond")

val TimePeriod<TimeUnit.Day>.lastSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "hourLastSecond")

val TimePeriod<TimeUnit.Hour>.lastSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "minuteLastSecond")

val TimePeriod<TimeUnit.Minute>.lastSecond: TimePeriod<TimeUnit.Second>

minute

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.minute: Int

minutePeriod

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.minutePeriod: TimePeriod<TimeUnit.Minute>

minutes

val TimeDifference<TimeUnit.Minute>.minutes: Int

@get:JvmName(name = "dayMinutes")

val TimePeriod<TimeUnit.Day>.minutes: Sequence<TimePeriod<TimeUnit.Minute>>

@get:JvmName(name = "hourMinutes")

val TimePeriod<TimeUnit.Hour>.minutes: Sequence<TimePeriod<TimeUnit.Minute>>

month

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.month: Month

monthPeriod

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.monthPeriod: TimePeriod<TimeUnit.Month>

months

val TimeDifference<TimeUnit.Month>.months: Int

val TimePeriod<TimeUnit.Year>.months: Sequence<TimePeriod<TimeUnit.Month>>

nanosecond

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.nanosecond: Int

nanoseconds

val TimeDifference<TimeUnit.Nanosecond>.nanoseconds: Int

nextDay

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.nextDay: TimePeriod<Unit>

Create a new TimePeriod by moving forward one day.

nextHour

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.nextHour: TimePeriod<Unit>

Create a new TimePeriod by moving forward one hour.

nextMinute

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.nextMinute: TimePeriod<Unit>

Create a new TimePeriod by moving forward one minute.

nextMonth

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.nextMonth: TimePeriod<Unit>

Create a new TimePeriod by moving forward one month.

nextNanosecond

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.nextNanosecond: TimePeriod<Unit>

Create a new TimePeriod by moving forward one nanosecond.

nextSecond

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.nextSecond: TimePeriod<Unit>

Create a new TimePeriod by moving forward one second.

nextYear

val <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.nextYear: TimePeriod<Unit>

Create a new TimePeriod by moving forward one year.

previousDay

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.previousDay: TimePeriod<Unit>

Create a new TimePeriod by moving backward one day.

previousHour

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.previousHour: TimePeriod<Unit>

Create a new TimePeriod by moving backward one hour.

previousMinute

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.previousMinute: TimePeriod<Unit>

Create a new TimePeriod by moving backward one minute.

previousMonth

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.previousMonth: TimePeriod<Unit>

Create a new TimePeriod by moving backward one month.

previousNanosecond

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.previousNanosecond: TimePeriod<Unit>

Create a new TimePeriod by moving backward one nanosecond.

previousSecond

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.previousSecond: TimePeriod<Unit>

Create a new TimePeriod by moving backward one second.

previousYear

val <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.previousYear: TimePeriod<Unit>

Create a new TimePeriod by moving backward one year.

second

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.second: Int

secondPeriod

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.secondPeriod: TimePeriod<TimeUnit.Second>

seconds

val TimeDifference<TimeUnit.Second>.seconds: Int

@get:JvmName(name = "hourSeconds")

val TimePeriod<TimeUnit.Hour>.seconds: Sequence<TimePeriod<TimeUnit.Second>>

@get:JvmName(name = "minuteSeconds")

val TimePeriod<TimeUnit.Minute>.seconds: Sequence<TimePeriod<TimeUnit.Second>>

year

val <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.year: Int

yearPeriod

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.yearPeriod: TimePeriod<TimeUnit.Year>

years

val TimeDifference<TimeUnit.Year>.years: Int

Functions

addingDays

fun <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.addingDays(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of days.

addingHours

fun <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.addingHours(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of hours.

addingMinutes

fun <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.addingMinutes(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of minutes.

addingMonths

fun <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.addingMonths(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of months.

addingNanoseconds

fun <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.addingNanoseconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of nanoseconds.

addingSeconds

fun <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.addingSeconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of seconds.

addingYears

fun <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.addingYears(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of years.

after

fun TimePeriod<*>.after(other: TimePeriod<*>): Boolean

before

fun TimePeriod<*>.before(other: TimePeriod<*>): Boolean

contains

fun TimePeriod<*>.contains(other: TimePeriod<*>): Boolean

convertToTimeZone

fun <Unit : TimeUnit> TimePeriod<Unit>.convertToTimeZone(timeZone: TimeZone): TimePeriod<Unit>

Construct a new TimePeriod by converting the receiver to a new TimeZone.

dayPeriod

fun LocalDate.dayPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Day>

fun LocalDateTime.dayPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Day>

difference

fun <Unit : TimeUnit> TimePeriod<Unit>.difference(to: TimePeriod<Unit>): TimeDifference<Unit>

during

fun TimePeriod<*>.during(other: TimePeriod<*>): Boolean

hourPeriod

fun LocalDateTime.hourPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Hour>

minus

@JvmName(name = "minusDay")

operator fun <Unit : DayOrBigger, TimeUnit> TimePeriod<TimeUnit.Day>.minus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Day>

@JvmName(name = "minusHour")

operator fun <Unit : HourOrBigger, TimeUnit> TimePeriod<TimeUnit.Hour>.minus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Hour>

@JvmName(name = "minusMinute")

operator fun <Unit : MinuteOrBigger, TimeUnit> TimePeriod<TimeUnit.Minute>.minus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Minute>

@JvmName(name = "minusMonth")

operator fun <Unit : MonthOrBigger, TimeUnit> TimePeriod<TimeUnit.Month>.minus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Month>

@JvmName(name = "minusNanosecond")

operator fun <Unit : NanosecondOrBigger, TimeUnit> TimePeriod<TimeUnit.Nanosecond>.minus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Nanosecond>

@JvmName(name = "minusSecond")

operator fun <Unit : SecondOrBigger, TimeUnit> TimePeriod<TimeUnit.Second>.minus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Second>

@JvmName(name = "minusYear")

operator fun TimePeriod<TimeUnit.Year>.minus(difference: TimeDifference<TimeUnit.Year>): TimePeriod<TimeUnit.Year>

Subtracts a TimeDifference from this TimePeriod.

operator fun <Unit : TimeUnit> TimePeriod<Unit>.minus(other: TimePeriod<Unit>): TimeDifference<Unit>

minutePeriod

fun LocalDateTime.minutePeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Minute>

monthPeriod

fun LocalDate.monthPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Month>

fun LocalDateTime.monthPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Month>

nextDay

fun Clock.nextDay(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Day>

nextHour

fun Clock.nextHour(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Hour>

nextMinute

fun Clock.nextMinute(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Minute>

nextMonth

fun Clock.nextMonth(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Month>

nextSecond

fun Clock.nextSecond(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Second>

nextYear

fun Clock.nextYear(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Year>

offset

fun <Unit : TimeUnit> TimePeriod<Unit>.offset(count: Int): TimePeriod<Unit>

fun Clock.offset(delta: Duration): Clock

Offset a Clock.

overlaps

fun TimePeriod<*>.overlaps(other: TimePeriod<*>): Boolean

plus

@JvmName(name = "plusDayOrBigger")

operator fun <Unit : DayOrBigger, TimeUnit> TimePeriod<TimeUnit.Day>.plus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Day>

@JvmName(name = "plusHourOrBigger")

operator fun <Unit : HourOrBigger, TimeUnit> TimePeriod<TimeUnit.Hour>.plus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Hour>

@JvmName(name = "plusMinuteOrBigger")

operator fun <Unit : MinuteOrBigger, TimeUnit> TimePeriod<TimeUnit.Minute>.plus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Minute>

@JvmName(name = "plusMonthOrBigger")

operator fun <Unit : MonthOrBigger, TimeUnit> TimePeriod<TimeUnit.Month>.plus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Month>

@JvmName(name = "plusNanosecondOrBigger")

operator fun <Unit : NanosecondOrBigger, TimeUnit> TimePeriod<TimeUnit.Nanosecond>.plus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Nanosecond>

@JvmName(name = "plusSecondOrBigger")

operator fun <Unit : SecondOrBigger, TimeUnit> TimePeriod<TimeUnit.Second>.plus(difference: TimeDifference<Unit>): TimePeriod<TimeUnit.Second>

@JvmName(name = "plusYear")

operator fun TimePeriod<TimeUnit.Year>.plus(difference: TimeDifference<TimeUnit.Year>): TimePeriod<TimeUnit.Year>

Adds a TimeDifference to this TimePeriod.

previousDay

fun Clock.previousDay(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Day>

previousHour

fun Clock.previousHour(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Hour>

previousMinute

fun Clock.previousMinute(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Minute>

previousMonth

fun Clock.previousMonth(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Month>

previousSecond

fun Clock.previousSecond(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Second>

previousYear

fun Clock.previousYear(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Year>

relation

fun TimePeriod<*>.relation(other: TimePeriod<*>): Relation

scaled

fun Clock.scaled(factor: Double): Clock

Scale a Clock.

secondPeriod

fun LocalDateTime.secondPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Second>

subtractingDays

fun <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingDays(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of days.

subtractingHours

fun <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingHours(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of hours.

subtractingMinutes

fun <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingMinutes(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of minutes.

subtractingMonths

fun <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingMonths(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of months.

subtractingNanoseconds

fun <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingNanoseconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of nanoseconds.

subtractingSeconds

fun <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingSeconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of seconds.

subtractingYears

fun <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingYears(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of years.

thisDay

fun Clock.thisDay(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Day>

Retrieve the current day of the Clock and TimeZone.

thisHour

fun Clock.thisHour(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Hour>

Retrieve the current hour of the Clock and TimeZone.

thisInstant

fun Clock.thisInstant(): Instant

thisMinute

fun Clock.thisMinute(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Minute>

Retrieve the current minute of the Clock and TimeZone.

thisMonth

fun Clock.thisMonth(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Month>

Retrieve the current month of the Clock and TimeZone.

thisNanosecond

fun Clock.thisNanosecond(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Nanosecond>

Retrieve the current nanosecond of the Clock and TimeZone.

thisSecond

fun Clock.thisSecond(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Second>

Retrieve the current second of the Clock and TimeZone.

thisYear

fun Clock.thisYear(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Year>

Retrieve the current year of the Clock and TimeZone.

today

fun Clock.today(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Day>

Retrieve the current day of the Clock and TimeZone.

toLocalDate

fun <Unit : TimeUnit, DayOrSmaller> TimePeriod<Unit>.toLocalDate(): LocalDate

Constructs a kotlinx.datetime.LocalDate from a TimePeriod with DayOrSmaller precision.

toLocalDateTime

fun <Unit : TimeUnit, HourOrSmaller> TimePeriod<Unit>.toLocalDateTime(): LocalDateTime

Constructs a kotlinx.datetime.LocalDateTime from a TimePeriod with HourOrSmaller precision.

tomorrow

fun Clock.tomorrow(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Day>

toNSDateComponents

fun TimePeriod<*>.toNSDateComponents(): <Error class: unknown class>

yearPeriod

fun LocalDate.yearPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Year>

fun LocalDateTime.yearPeriod(timeZone: TimeZone): TimePeriod<TimeUnit.Year>

yesterday

fun Clock.yesterday(timeZone: TimeZone = TimeZone.currentSystemDefault()): TimePeriod<TimeUnit.Day>